

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Point;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.image.BufferedImage;
import java.util.ArrayList;
import java.util.Random;

import javax.swing.JPanel;
import javax.swing.SwingUtilities;

/*import foodNhill.Anthill;
import foodNhill.FoodDepot;
import foodNhill.Rectangle;*/

import barricades.Barricade;
import barricades.BottomDiagBarricade;
import barricades.HorizontalBarricade;
import barricades.TopDiagBarricade;
import barricades.VerticalBarricade;

public class AntSimulation {
	
	/**
	 * Anzahl der Ameisen fuer diese Simulation
	 */
	private int numAnts; 
	
	/**
	 * Gibt an bis zu welcher Ameise die Simulation ausgefuehrt werden soll
	 */
	private int numAntsIndex=0;
	
	/**
	 * Simulationsbox, d.h. "Waldboden" auf dem sich die Ameisen bewegen und 
	 * in dem die Pheromone verteilt werden
	 */
	private int [][] forestground; 
	
	/**
	 * Array, das alle zu simulierenden Ameisen beinhaltet
	 */
	public defAnt [] antArray;
	
	/**
	 * GUI-Grundlage zur Visualisierung und Einstellung aller Eigenschaften
	 */
	private Window window;
	
	/**
	 * auf diesem Panel werden, die Ameisen, deren Duftspuren, die Barricaden und
	 * die Huegel visualisiert
	 */
	public JPanel simulationArea;
	
	/**
	 * gibt an ob die Simulation bereits gestartet worden ist
	 */
	private boolean started;
	/**
	 * die Breite und Hoehe der Simulationsbox, dienen auch als Grundlage
	 * fuer die Groesse des Fensters
	 */
	private  int simulationWidth, simulationHeight;
	
	/**
	 * specifies how many pheromone trail vapories
	 */
	public static int vaporising=5;

	/**
	 * gibt an ob das Fenster grade minimiert wurde
	 */
	private boolean wasMinimized;
	
	/**
	 * gibt an welcher Startmodus fuer die Ameise gewaehlt wurde: true=intervall, false=normal
	 */
	private boolean startMode;
	
	/**
	 * definiert den gruenen Farbton fuer den Hintergrund
	 */
	public static final Color bgColor = new Color(154,205,50);
	
	/**
	 * auf diese Layer wird gezeichnet
	 */
	private BufferedImage underlayer,previewLayer;
	
	/**
	 * merkt sich das letzte nicht-aktive Futterdepot bzw. die
	 * vorherige Lage des Ameisenhuegels, damit nicht immer das
	 * gesamte Bild neugemalt werden muss
	 */
	private Anthill old_anthill;
	
	
	
	private FoodDepot old_feed;
	/**
	 * die letzte erzeugte Barricade (also die erste die entfernt werden muss)
	 */
	private Barricade bar_to_be_removed;
	
	/**
	 * aktuelle Ameisennummer bei der eine unterbrochene Simulation einsetzen muesste
	 */
	public  int stat_j;
	/**
	 * der Ameisenhuegel
	 */
	public Anthill anthill_rectangle;
	/**
	 * beinhaltet alle gesetzten Barricaden
	 */
	private ArrayList<Barricade> barricades;
	/**
	 * beinhaltet alle gesetzten Futterdepots
	 */
	private ArrayList<FoodDepot> feed_depots;
	
	/**
	 * Konstruktor
	 * erzeugt eine neue AntSimulation, wobei ein Start-Ameisenhuegel auf die
	 * Position (100,100) gesetzt wird
	 * @param width Breite der Simulationsbox
	 * @param height Hoehe der Simulationsbox
	 */
	public AntSimulation(int width, int height){
		
		this.simulationWidth=width;
		this.simulationHeight=height;
		this.started=false;
		this.stat_j=0;
		
		anthill_rectangle=new Anthill(new Point(100,100),Window.ANTS_INIT/16);
		
		old_anthill= new Anthill(anthill_rectangle);

		barricades=new ArrayList<Barricade>();
		feed_depots=new ArrayList<FoodDepot>();
		
		this.initializeGUI();
		
	}//constructor
	
	/*
	 * getter 
	 */
	/**
	 * @return Simulationsbreite
	 */
	public int getSimWidth(){
		return this.simulationWidth;
	}
	/**
	 * 
	 * @return Simulationshoehe
	 */
	public int getSimHeight(){
		return this.simulationHeight;
	}
	
	/**
	 * 
	 * @return Panel, auf dem visualisiert wird
	 */
	public JPanel getSimArea(){
		return this.simulationArea;
	}
	
	/**
	 * 
	 * @return Index der akt. Ameise waehrend Simulationsdurchlauf
	 */
	public int getStat_J(){
		return this.stat_j;
	}
	
	/**
	 * mit dieser Ameise soll die Simulation weitergefuehrt werden
	 * @param i
	 */
	public void setStat_j(int i){
		stat_j=i;
	}
	
	/**
	 * Anzahl der zu simulierenden Ameisen
	 * @return numAnts
	 */
	public int getNumAnts(){
		return this.numAnts;
	}
	
		
	/**
	 * 
	 * @return Wertearray fuer Pheromone und Ameisen
	 */
	public int[][] getForestground(){
		return this.forestground;
	}
	
	/**
	 * 
	 * @return true, wenn die Simulation bereits gestartet wurde
	 */
	public boolean isStarted(){
		return this.started;
	}
	
	/**
	 * 
	 * @return das Grund-Fenster
	 */
	public Window getWindow(){
		return this.window;
	}
	
	/**
	 * gibt zurueck in welchem Modus die Ameisen gestartet werden
	 * @return true, wenn Intervallstart, false wenn Normalestartart
	 */
	public boolean isIntervallStart(){
		return startMode;
	}
	
	public FoodDepot getDepot(int i){
		return feed_depots.get(i);
	}
	
	
	/*
	 * setter
	 */
	
	/**
	 * setzt einen Punkt im BufferedImage Underlayer mit einem bestimmten
	 * Farbwert fest
	 * @param x -Koordinate des Punktes
	 * @param y -Koordinate des Punktes
	 * @param rgb der Farbwert
	 */
	public void setUnderlayerColor(int x, int y, int rgb){
		this.underlayer.setRGB(x, y, rgb);
	}
	
	/**
	 * setzt Parameter auf uebergebenen Wert
	 * @param started
	 */
	public void setStarted(boolean started){
		this.started=started;
	}
	
	/**
	 * setzt den Startmodus
	 * @param intervall true wenn Intervallsmodus
	 */
	public void setIntervallStart(boolean intervall){
		startMode=intervall;
	}
	
	/**
	 * setzt Parameter auf uebergebenen Wert
	 * @param min
	 */
	public void setWasMinimized(boolean min){
		wasMinimized=min;
	}
	/*
	 * Methods
	 */
	
	public void changeAllAntsNoFood( int noFood ){
		if( this.antArray == null || this.antArray.length <= 0 )
			return;
		for( Ant thisAnt : (Ant[]) this.antArray ){
			if( thisAnt.food == Ant.NOFOOD )
				thisAnt.food = noFood;
		}
	}
	
	public void changeAllAntsGotFood( int gotFood ){
		if( this.antArray == null || this.antArray.length <= 0 )
			return;
		for( Ant thisAnt : (Ant[]) this.antArray ){
			if( thisAnt.food == Ant.GOTFOOD )
				thisAnt.food = gotFood;
		}
	}
	
	/**
	 * passt die Groesse eines Rectangles an
	 * @param caseNumber 1-Ameisenhuegel, 2-Futterdepot
	 */
	public void updateRectangle(int caseNumber){
		switch(caseNumber){
		
		case 1:
				old_anthill=new Anthill(anthill_rectangle);		
				anthill_rectangle.resize(window.getNumberOfAnts()/16);
				break;
		case 2: 
			FoodDepot active=feed_depots.get(window.getActiveDepot());
				old_feed=new FoodDepot(active);
				active.resize(window.getSizeFeed());
				active.setType(window.getFeedVariety());
				break;
		default:;		
	}
		revalidatePreview();
	}//updateRectangle(int caseNumber)
	
	/**
	 * zeichnet Duftspur und anschliessend die Ameisen
	 * @param g das Graphics Object auf dem gezeichnet wird
	 */
	public  void draw( Graphics g ){
		for( int i = 0; i < numAntsIndex; i++){
			antArray[i].drawTrail( underlayer.getGraphics() );
		}
		for( int i = 0; i < numAntsIndex; i++ ){
			antArray[i].draw( underlayer.getGraphics() );
		}
		
		g.drawImage(underlayer, 0, 0, null);
		
	}//draw(Graphics g)
	
	/**
	 * Zeichnen der Simulationsvorschau 
	 * @param g Graphics Object auf das gezeichnet wird
	 */
	public void preview(Graphics g){
		g.drawImage(previewLayer,0,0,null);
	}
	
	/**
	 * Initialisierung der GUI
	 */
	private  void initializeGUI(){
		
		this.simulationArea = new JPanel(true) {
			private static final long serialVersionUID = 1L;
			protected void paintComponent( Graphics g ){						
				super.paintComponent( g );
				if(started){
					draw( g );
				}else{
					preview(g);
				}
			}	
		};
		
		this.simulationArea.addMouseListener(new MouseListener(){

			public void mouseClicked(MouseEvent mEV) {
			
			if(!started){
				if(window.isFeed()){
					
					if(mEV.getButton()==MouseEvent.BUTTON1){
						//wenn futterhuegel hinzugefuegt werden sollen
						if(window.isIncMode() || feed_depots.size()==0){
							feed_depots.add(new FoodDepot(mEV.getPoint(),window.getSizeFeed(),window.getFeedVariety()));
							window.incFeedDepot();
							window.setActive(feed_depots.size()-1);
						}
						//es wird nur die position geaendert
						else{
							old_feed=new FoodDepot(feed_depots.get(window.getActiveDepot()));
							FoodDepot active=feed_depots.get(window.getActiveDepot());
							active.setPosition(mEV.getPoint());
							active.setType(window.getFeedVariety());
						}
					}else{
						window.removeFeedDepot();
					}
					
				}else if(window.isAnthill()){
					old_anthill=new Anthill(anthill_rectangle);
					anthill_rectangle.setPosition(mEV.getPoint());
				}else if(window.isBarricades()){
					//left button pressed
					if(mEV.getButton()==MouseEvent.BUTTON1){
						barricades.add(window.getSelectedBarricade(mEV.getPoint()));
					}
					//other buttons
					else{
						if(barricades.size()!=0){
							bar_to_be_removed=barricades.get(barricades.size()-1);
							barricades.remove(bar_to_be_removed);
						}
					}
				}
				revalidatePreview();
			}else if(started && startMode){
					System.out.println(">>>simulation already running");
					if(anthill_rectangle.isInRect(mEV.getPoint().x,mEV.getPoint().y)){
						startAnts();
						
					}
			}
				
			}//mouseClicked(MouseEvent mEV)

			public void mouseEntered(MouseEvent e) {
				// TODO Auto-generated method stub
				
			}

			public void mouseExited(MouseEvent e) {
				// TODO Auto-generated method stub
				
			}

			public void mousePressed(MouseEvent e) {
				// TODO Auto-generated method stub
				
			}

			public void mouseReleased(MouseEvent e) {
				// TODO Auto-generated method stub
				
			}
			
		});
		
		this.window=new Window(this);
		//this.adv_sets=new Advanced_Settings(this);
		
	
		
		//**********NEWfeed
		initializePreviewImage();
		initializeBackgroundImage(simulationWidth,simulationHeight);
		
	}//initializeGUI
	
	public void startAnts(){
		
			if(numAntsIndex<numAnts){
				System.out.println(">>>klick on anthill -> initializing further ants");
				int help=numAnts/4;
				initializeAnts(numAntsIndex, numAntsIndex+help);
				numAntsIndex+=help;
				}else{
					System.out.println(">>>ants already completely initialized");
				}
			
		
		}
	
	/**
	 * wenn nur ein restart gemacht wird, d.h. dass das Fenster selbst
	 * und die bereits gesetzten Huegel etc. erhalten bleiben koennen
	 */
	public void newSettings(){
		numAntsIndex=0;
		setStarted(false);
		initializeBackgroundImage(simulationWidth, simulationHeight);
		revalidatePreview();
	}//newSettings()
		
	/**
	 * entfernt ein Futterdepot aus der Futterdepotliste
	 * @param i Index des Futterdepots, das entfernt werden soll
	 */
	public void removeFeedDepot(int i){
		old_feed=feed_depots.get(i);
		feed_depots.remove(i);
		revalidatePreview();
	}
	
	/**
	 * Initialisierunge des Hintergrunds
	 * @param width Breite des Hintergrundes
	 * @param height Hoehe des Hintergrundes
	 */
	private void initializeBackgroundImage( int width, int height ){
		underlayer=(BufferedImage) simulationArea.createImage( width, height );
				
		Graphics g = underlayer.getGraphics();
		g.setColor( bgColor );
		g.fillRect(0, 0, width, height);
	}
	
	/**
	 * Initialisierung des Vorschaubildes
	 */
	private void initializePreviewImage(){
		previewLayer=(BufferedImage)simulationArea.createImage(simulationWidth,simulationHeight);
		Graphics g = previewLayer.getGraphics();
		g.setColor(bgColor);
		g.fillRect(0,0,simulationWidth,simulationHeight);
	}


	
	/**
	 * Aufruf der Zeichenmethoden fuer alle entscheidenden Elemente des Vorschaubildes
	 * Achtung: Barricades werden in der Vorschau schwarz gezeichnet im Programm selbst
	 * 	nicht
	 */
	private void revalidatePreview(){
		
		Graphics g = previewLayer.getGraphics();
		
		//delete from view: old version
		g.setColor(bgColor);
	
		if(old_feed!=null)
			old_feed.drawPreviewPosition(g);
		if(bar_to_be_removed!=null)
			bar_to_be_removed.drawPosition(g);
		old_anthill.drawPreviewPosition(g);
		
		//g.setColor(Color.cyan);
		
		for(int i=0;i<feed_depots.size();i++){
			//feed_depots.get(i).drawPreviewPosition(g);
			FoodDepot depot=feed_depots.get(i);
			g.drawImage(depot.loadImage(),depot.x, depot.y, depot.size,depot.size, simulationArea);
			
		}

		
		g.setColor(Color.black);
		for(int i=0;i<barricades.size();i++){
			barricades.get(i).drawPosition(g);
		}
		
		//g.setColor(Color.magenta);
	//	anthill_rectangle.drawPreviewPosition(g);
		g.drawImage(anthill_rectangle.loadHill(),anthill_rectangle.x, anthill_rectangle.y, anthill_rectangle.size,anthill_rectangle.size, simulationArea);
		
		
		
		simulationArea.repaint();
	}//drawFeedDepot(boolean preview)
	
	/**
	 * Initialisierung der Simulationsbedingungen, d.h.
	 * - Belegen der Simulationsbox mit den Werten fuer Futter, Ameisenhuegel
	 * und Barricaden
	 * - Berechnen der Ameisen und deren Anfangspositionen auf dem Ameisenhuegel
	 */
	public void initialzeSimulation(){
		
		forestground = new int [simulationWidth][simulationHeight];
		
		//belegt forestground mit defaultwerten
		for( int i = 0; i < simulationWidth; i++ ){
			for( int j = 0; j < simulationHeight; j++ ){
					forestground[i][j] = 1;//tmpColor;
			}//for - j
		}//for - i
		
		//Achtung bei restart!!!!!!!!
		ArrayList<Barricade> bar_helper=new ArrayList<Barricade>();
		
		//initializes barricades 
		for(int i=0;i<barricades.size();i++){
			Barricade bar=barricades.get(i);
		
			if(bar instanceof BottomDiagBarricade){
				Barricade bar1=new BottomDiagBarricade(bar);
				Barricade bar2=new BottomDiagBarricade(bar);
				
bar1.setPosition(new Point(bar.x_start+1,bar.y_start), new Point(bar.x_end+1,bar.y_end));
				
				bar1.setPosition(new Point(bar.x_start,bar.y_start+1), new Point(bar.x_end,bar.y_end+1));
				bar_helper.add(bar1);
				bar_helper.add(bar2);
				
				initializeBarricades(bar1);
				initializeBarricades(bar2);
			}
			else if(bar instanceof TopDiagBarricade){
				Barricade bar1=new TopDiagBarricade(bar);
				Barricade bar2=new TopDiagBarricade(bar);
				
	bar1.setPosition(new Point(bar.x_start+1,bar.y_start), new Point(bar.x_end+1,bar.y_end));
				
				bar1.setPosition(new Point(bar.x_start,bar.y_start+1), new Point(bar.x_end,bar.y_end+1));
				bar_helper.add(bar1);
				bar_helper.add(bar2);
				
				initializeBarricades(bar1);
				initializeBarricades(bar2);
			}
			initializeBarricades(bar);
		
		}
		
		Graphics g=underlayer.getGraphics();
		//initializes feed depot
		for(int l=0;l<feed_depots.size();l++){
			
			FoodDepot depot=feed_depots.get(l);
			int f_x=depot.x;
			int f_y=depot.y;
			int feed_size=depot.size;
			int degree=depot.getDegree();
			
			g.drawImage(depot.loadImage(),f_x, f_y,feed_size,feed_size, simulationArea);
			
			for(int i=f_x;i<f_x+feed_size;i++){
				for(int j=f_y;j<f_y+feed_size;j++){
					forestground[i][j] = degree;
					//underlayer.setRGB( i, j, Color.cyan.getRGB() );
					
				}
			}
			
		}
		
		//initializes ant_hill
		int anthill_size=anthill_rectangle.size;
		
		int a_x=anthill_rectangle.x;
		int a_y=anthill_rectangle.y;
		
		g.drawImage(anthill_rectangle.loadHill(),a_x, a_y, anthill_size,anthill_size, simulationArea);
		
		for(int i=a_x;i<a_x+anthill_size;i++){
			for(int j=a_y;j<a_y+anthill_size;j++){
				forestground[i][j] = -255;
				//underlayer.setRGB( i, j, Color.green.getRGB() );
			}
		}
		
		
		numAnts=window.getNumberOfAnts();
		antArray = new Ant[numAnts];
			
//d.h. wenn nicht bei klick auf huegle gestartet werden soll
		if(!startMode){
		initializeAnts(0, numAnts);
		numAntsIndex=numAnts;
		}
		
		System.out.println(">>>simulation initialized");
		
	}//initializeSimulation()

	/**
	 * initializiert Ameisen in bestimmten Wertebereichen
	 * @param from beginnend mit
	 * @param to Grenze (wird nicht mehr mitinitialisert)
	 */
	private void initializeAnts(int from, int to){
		Ant.DIRECTION [] tmp = Ant.defaultPrefDir;
		
		Random rand = new Random();
		Point start = anthill_rectangle.getPosition();
		//damit ameisen dort noch nicht  starten
		//config size s.u.
		
		start.x--;
		start.y--;
		
		int config_size=anthill_rectangle.size+1;//da ameisen nicht direkt im huegel starten koennen

		
		//die Startpositionen der Ameisen bestimmen
		for( int i = from; i < to; i++ ){//( int i = 0; i < numAnts; i++ )
			Point newP=start;
			//alternative version, damit ameisen nicht vor hindernissen starten
			do{
				switch (i%4){	
					case 0: newP=new Point(start.x+rand.nextInt(config_size),start.y);break;
					case 1:	newP=new Point(start.x+(config_size),start.y+rand.nextInt(config_size));break;
					case 2:newP=new Point(start.x,start.y+rand.nextInt(config_size));break;
					case 3:newP=new Point(start.x+rand.nextInt(config_size),start.y+config_size);break;					
				}
			}while(forestground[newP.x][newP.y]==-255);//==-255
			
			antArray[i]=new Ant(newP,tmp[i/(numAnts/16)],this);
		}//for - i
	}
	
	/**
	 * Hilfsfunktion zur Zuweisung der Werte der verschiedenen Barricaden
	 * in die Simulationsbox
	 * (Damit diese auch nicht ueber das Spielfeld hinausragen)
	 * @param bar Barricade, die "eingelesen" werden soll
	 */
	private void initializeBarricades(Barricade bar){
	
		bar.setInBounds(simulationWidth-1, simulationHeight-1);
		
		
		int x1=bar.x_start;
		int x2=bar.x_end;
		int y1=bar.y_start;
		int y2=bar.y_end;
		
	
		
		if(bar instanceof HorizontalBarricade){
			for(int j=x1;j<=(x2);j++){
								forestground[j][y1]=-255;
								underlayer.setRGB(j, y1,Color.orange.getRGB());
							}
		}
		else if(bar instanceof VerticalBarricade){

			for(int j=y1;j<=y2;j++){
				forestground[x1][j]=-255;
				underlayer.setRGB(x1, j,Color.orange.getRGB());
			}
		}
		else if(bar instanceof BottomDiagBarricade){
			 int k=y1;
										for(int j=x1;j<=x2;j++){
											forestground[j][k]=-255;
											underlayer.setRGB(j, k,Color.orange.getRGB());
											k--;
										}
		}
		else{

		 	int l=y1;
										for(int j=x1;j<=x2;j++){
											forestground[j][l]=-255;
											underlayer.setRGB(j, l,Color.orange.getRGB());
											l++;
										}
		};

		}
	
	/**
	 * Testet ob der Ameisenhuegel und die Futterdepots richtig gesetzt sind,
	 * d.h. innerhalb der Simulationsbox und sich gegenseitig nicht ueberschneiden
	 * @return true, wenn die Huegel korrekt gesetzt sind
	 */
	public  boolean isCorrectlySet(){
		if(anthill_rectangle.isOutOfBounds(simulationWidth-1, simulationHeight-1))
			return false;
		for(int i=0; i<feed_depots.size();i++){
			if(anthill_rectangle.interlapse(feed_depots.get(i))
					||feed_depots.get(i).isOutOfBounds(simulationWidth, simulationHeight)){
						return false;
					}
		}
			return true;
	}//isCorrectlySet
	
	/**
	 * Started extra Thread zum neuzeichnen, damit der Hauptthread nicht warten muss
	 */
	private  void repaintSimArea() {
		SwingUtilities.invokeLater(new Runnable() {
			 public void run() {
				 simulationArea.repaint();
			 }//run
		 });
		 //SwingUtilities.invokeLater(rp);
	}//repaintSimArea(final JPanel panel)

	/**
	 * laesst Pheromone vom Waldboden nach gewisser Zeit verdunsten
	 */
	 private  void revalidateForestGround(){
	
		 Graphics g = underlayer.getGraphics();
		 
		 for( int i = 0; i < forestground.length; i++ ){
				for( int j = 0; j < forestground[0].length; j++ ){
					//System.out.println("Waldboden vorher"+forestground[i][j]);
					if(forestground[i][j]>0){//evtl duftspur
						if (forestground[i][j]<=255){//kein futter soll beruecksichtigt werden
						
							forestground[i][j]-=vaporising;
							if(forestground[i][j]<=0){//damit es immer positiv bleibt
								forestground[i][j]=1;
								
							
							
						}
							//hier wird neu gemalt
							int tmp=forestground[i][j];
							Color tmpColor = new Color( -tmp/2+154, 205-tmp/2, 50+tmp/2 );
							g.setColor(tmpColor);
							g.fillRect(i, j, 1	, 1);
						}
					}
					else{//negativ ->ameise
						if(forestground[i][j]>=-255){
						
							forestground[i][j]+=vaporising;
							if(forestground[i][j]>=0){//damit es immer negativ bleibt
								forestground[i][j]=-1;	
								
							}
							//hier brauch nicht neu gemalt werden weil ne ameise draufsteht
						
						}
					}
					
					//System.out.println("Waldboden nachher"+forestground[i][j]);
				}
			}
		 
		 //ueberschuss gibts nicht mehr
		 	for(int i=0;i<numAntsIndex;i++){//numAnts
		 		antArray[i].getPtrail().getUeberschuss().clear();
		 		antArray[i].getPtrail().getAbnahme().clear();
		 	}
		}
	 
	/**
	 * die eigentliche Simulation, also die Bewegung aller Ameisen hintereinander
	 * laeuft nur 100.000 Schritte
	 * @param j der Index der Ameise, bei der die Simulation gestartet wird
	 * @throws InterruptedException , wenn man die Simualtion anhalten moechte
	 */
	public  void simulate(int j) throws InterruptedException{
		for(int i = 0; i < 100000; i++ ){
			
			/*
			 * Quellcode falls er mittig unterbricht - das tut er aber meistens nicht...(vllt wegen sleep)
			 * sonst wuerde auch einfaches j=0 reichen bin mir aber nicht 100%ig sicher ;)
			 * koennte wohl in einem von viiiielen faellen schief gehen
			 */
			for( stat_j = j; stat_j < numAntsIndex; stat_j++ ){
//				System.out.println("\n"+j+". Ameise\n");
				antArray[stat_j].stepForward();
				
			}//for - j
			j=0;
			
			if(i%100==0){
				revalidateForestGround();
				
		}
			
			repaintSimArea();
			
				Thread.sleep(35);
		
		}//for - i
		System.out.println("Default end of simulation");

	}//simulate()

}//class
